package usbcali.edu.presentation.businessDelegate;

import usbcali.edu.persistencia.Cargos;
import usbcali.edu.persistencia.CcUsuario;
import usbcali.edu.persistencia.CcUsuarioId;
import usbcali.edu.persistencia.CentroDeCostos;
import usbcali.edu.persistencia.ClaseAlimento;
import usbcali.edu.persistencia.ComposicionSala;
import usbcali.edu.persistencia.ComposicionSalaId;
import usbcali.edu.persistencia.Departamentos;
import usbcali.edu.persistencia.DepartamentosId;
import usbcali.edu.persistencia.ElemAudiovisuales;
import usbcali.edu.persistencia.ElemAudiovisualesId;
import usbcali.edu.persistencia.Entidades;
import usbcali.edu.persistencia.Funcionarios;
import usbcali.edu.persistencia.HorarioRxsala;
import usbcali.edu.persistencia.HorarioRxsalaId;
import usbcali.edu.persistencia.ImagenFormas;
import usbcali.edu.persistencia.ProSerOfrecen;
import usbcali.edu.persistencia.ProSerOfrecenId;
import usbcali.edu.persistencia.Proveedores;
import usbcali.edu.persistencia.RDRequerimientos;
import usbcali.edu.persistencia.RHorariosReserva;
import usbcali.edu.persistencia.Reservas;
import usbcali.edu.persistencia.Reservaxrequerimient;
import usbcali.edu.persistencia.Restaurantes;
import usbcali.edu.persistencia.Salas;
import usbcali.edu.persistencia.Salasxusuarios;
import usbcali.edu.persistencia.SalasxusuariosId;
import usbcali.edu.persistencia.Salaxtforma;
import usbcali.edu.persistencia.SalaxtformaId;
import usbcali.edu.persistencia.Secciones;
import usbcali.edu.persistencia.SeccionesId;
import usbcali.edu.persistencia.SerOfrecen;
import usbcali.edu.persistencia.SolAlixfuncionarios;
import usbcali.edu.persistencia.SolEventos;
import usbcali.edu.persistencia.SoliAliAsisExternos;
import usbcali.edu.persistencia.SolicitAlimAstExter;
import usbcali.edu.persistencia.SoltAlimentos;
import usbcali.edu.persistencia.SubArea;
import usbcali.edu.persistencia.SubAreaId;
import usbcali.edu.persistencia.TAlimentos;
import usbcali.edu.persistencia.TElementos;
import usbcali.edu.persistencia.TForSalas;
import usbcali.edu.persistencia.TProveedores;
import usbcali.edu.persistencia.TarifaAlimentos;
import usbcali.edu.persistencia.TarifaAlimentosId;
import usbcali.edu.persistencia.TipoTrabajo;
import usbcali.edu.persistencia.TipoUsuarios;
import usbcali.edu.persistencia.Tiposolicitudes;
import usbcali.edu.persistencia.Usuarios;
import usbcali.edu.persistencia.control.CargosLogic;
import usbcali.edu.persistencia.control.CcUsuarioLogic;
import usbcali.edu.persistencia.control.CentroDeCostosLogic;
import usbcali.edu.persistencia.control.ClaseAlimentoLogic;
import usbcali.edu.persistencia.control.ComposicionSalaLogic;
import usbcali.edu.persistencia.control.DepartamentosLogic;
import usbcali.edu.persistencia.control.ElemAudiovisualesLogic;
import usbcali.edu.persistencia.control.EntidadesLogic;
import usbcali.edu.persistencia.control.FuncionariosLogic;
import usbcali.edu.persistencia.control.HorarioRxsalaLogic;
import usbcali.edu.persistencia.control.ICargosLogic;
import usbcali.edu.persistencia.control.ICcUsuarioLogic;
import usbcali.edu.persistencia.control.ICentroDeCostosLogic;
import usbcali.edu.persistencia.control.IClaseAlimentoLogic;
import usbcali.edu.persistencia.control.IComposicionSalaLogic;
import usbcali.edu.persistencia.control.IDepartamentosLogic;
import usbcali.edu.persistencia.control.IElemAudiovisualesLogic;
import usbcali.edu.persistencia.control.IEntidadesLogic;
import usbcali.edu.persistencia.control.IFuncionariosLogic;
import usbcali.edu.persistencia.control.IHorarioRxsalaLogic;
import usbcali.edu.persistencia.control.IImagenFormasLogic;
import usbcali.edu.persistencia.control.IProSerOfrecenLogic;
import usbcali.edu.persistencia.control.IProveedoresLogic;
import usbcali.edu.persistencia.control.IRDRequerimientosLogic;
import usbcali.edu.persistencia.control.IRHorariosReservaLogic;
import usbcali.edu.persistencia.control.IReservasLogic;
import usbcali.edu.persistencia.control.IReservaxrequerimientLogic;
import usbcali.edu.persistencia.control.IRestaurantesLogic;
import usbcali.edu.persistencia.control.ISalasLogic;
import usbcali.edu.persistencia.control.ISalasxusuariosLogic;
import usbcali.edu.persistencia.control.ISalaxtformaLogic;
import usbcali.edu.persistencia.control.ISeccionesLogic;
import usbcali.edu.persistencia.control.ISerOfrecenLogic;
import usbcali.edu.persistencia.control.ISolAlixfuncionariosLogic;
import usbcali.edu.persistencia.control.ISolEventosLogic;
import usbcali.edu.persistencia.control.ISoliAliAsisExternosLogic;
import usbcali.edu.persistencia.control.ISolicitAlimAstExterLogic;
import usbcali.edu.persistencia.control.ISoltAlimentosLogic;
import usbcali.edu.persistencia.control.ISubAreaLogic;
import usbcali.edu.persistencia.control.ITAlimentosLogic;
import usbcali.edu.persistencia.control.ITElementosLogic;
import usbcali.edu.persistencia.control.ITForSalasLogic;
import usbcali.edu.persistencia.control.ITProveedoresLogic;
import usbcali.edu.persistencia.control.ITarifaAlimentosLogic;
import usbcali.edu.persistencia.control.ITipoTrabajoLogic;
import usbcali.edu.persistencia.control.ITipoUsuariosLogic;
import usbcali.edu.persistencia.control.ITiposolicitudesLogic;
import usbcali.edu.persistencia.control.IUsuariosLogic;
import usbcali.edu.persistencia.control.ImagenFormasLogic;
import usbcali.edu.persistencia.control.ProSerOfrecenLogic;
import usbcali.edu.persistencia.control.ProveedoresLogic;
import usbcali.edu.persistencia.control.RDRequerimientosLogic;
import usbcali.edu.persistencia.control.RHorariosReservaLogic;
import usbcali.edu.persistencia.control.ReservasLogic;
import usbcali.edu.persistencia.control.ReservaxrequerimientLogic;
import usbcali.edu.persistencia.control.RestaurantesLogic;
import usbcali.edu.persistencia.control.SalasLogic;
import usbcali.edu.persistencia.control.SalasxusuariosLogic;
import usbcali.edu.persistencia.control.SalaxtformaLogic;
import usbcali.edu.persistencia.control.SeccionesLogic;
import usbcali.edu.persistencia.control.SerOfrecenLogic;
import usbcali.edu.persistencia.control.SolAlixfuncionariosLogic;
import usbcali.edu.persistencia.control.SolEventosLogic;
import usbcali.edu.persistencia.control.SoliAliAsisExternosLogic;
import usbcali.edu.persistencia.control.SolicitAlimAstExterLogic;
import usbcali.edu.persistencia.control.SoltAlimentosLogic;
import usbcali.edu.persistencia.control.SubAreaLogic;
import usbcali.edu.persistencia.control.TAlimentosLogic;
import usbcali.edu.persistencia.control.TElementosLogic;
import usbcali.edu.persistencia.control.TForSalasLogic;
import usbcali.edu.persistencia.control.TProveedoresLogic;
import usbcali.edu.persistencia.control.TarifaAlimentosLogic;
import usbcali.edu.persistencia.control.TipoTrabajoLogic;
import usbcali.edu.persistencia.control.TipoUsuariosLogic;
import usbcali.edu.persistencia.control.TiposolicitudesLogic;
import usbcali.edu.persistencia.control.UsuariosLogic;

import java.math.BigDecimal;

import java.sql.Blob;
import java.util.Date;
import java.util.List;
import java.util.Set;


/**
* Use a Business Delegate to reduce coupling between presentation-tier clients and business services.
* The Business Delegate hides the underlying implementation details of the business service, such as lookup and access details of the EJB architecture.
*
* The Business Delegate acts as a client-side business abstraction; it provides an abstraction for, and thus hides,
* the implementation of the business services. Using a Business Delegate reduces the coupling between presentation-tier clients and
* the system's business services. Depending on the implementation strategy, the Business Delegate may shield clients from possible
* volatility in the implementation of the business service API. Potentially, this reduces the number of changes that must be made to the
* presentation-tier client code when the business service API or its underlying implementation changes.
*
* However, interface methods in the Business Delegate may still require modification if the underlying business service API changes.
* Admittedly, though, it is more likely that changes will be made to the business service rather than to the Business Delegate.
*
* Often, developers are skeptical when a design goal such as abstracting the business layer causes additional upfront work in return
* for future gains. However, using this pattern or its strategies results in only a small amount of additional upfront work and provides
* considerable benefits. The main benefit is hiding the details of the underlying service. For example, the client can become transparent
* to naming and lookup services. The Business Delegate also handles the exceptions from the business services, such as java.rmi.Remote
* exceptions, Java Messages Service (JMS) exceptions and so on. The Business Delegate may intercept such service level exceptions and
* generate application level exceptions instead. Application level exceptions are easier to handle by the clients, and may be user friendly.
* The Business Delegate may also transparently perform any retry or recovery operations necessary in the event of a service failure without
* exposing the client to the problem until it is determined that the problem is not resolvable. These gains present a compelling reason to
* use the pattern.
*
* Another benefit is that the delegate may cache results and references to remote business services. Caching can significantly improve performance,
* because it limits unnecessary and potentially costly round trips over the network.
*
* A Business Delegate uses a component called the Lookup Service. The Lookup Service is responsible for hiding the underlying implementation
* details of the business service lookup code. The Lookup Service may be written as part of the Delegate, but we recommend that it be
* implemented as a separate component, as outlined in the Service Locator pattern (See "Service Locator" on page 368.)
*
* When the Business Delegate is used with a Session Facade, typically there is a one-to-one relationship between the two.
* This one-to-one relationship exists because logic that might have been encapsulated in a Business Delegate relating to its interaction
* with multiple business services (creating a one-to-many relationship) will often be factored back into a Session Facade.
*
* Finally, it should be noted that this pattern could be used to reduce coupling between other tiers, not simply the presentation and the
* business tiers.
*
* @author Zathura Code Generator http://code.google.com/p/zathura
*
*/
public class BusinessDelegatorView {
    private BusinessDelegatorView() {
    }

    public static List<Cargos> getCargos() throws Exception {
        ICargosLogic cargosLogic = new CargosLogic();

        return cargosLogic.getCargos();
    }

    public static void saveCargos(String codCargo,String nombre) throws Exception {
        ICargosLogic cargosLogic = new CargosLogic();
        cargosLogic.saveCargos(codCargo,nombre);
    }

    public static void deleteCargos(String codCargo) throws Exception {
        ICargosLogic cargosLogic = new CargosLogic();
        cargosLogic.deleteCargos(codCargo);
    }

    public static void updateCargos(String codCargo,String nombre) throws Exception {
        ICargosLogic cargosLogic = new CargosLogic();
        cargosLogic.updateCargos(codCargo,nombre);
    }

    public static Cargos getCargos(String codCargo) throws Exception {
        ICargosLogic cargosLogic = new CargosLogic();
        Cargos cargos = null;

        try {
            cargos = cargosLogic.getCargos(codCargo);
        } catch (Exception e) {
            throw e;
        }

        return cargos;
    }

    public static List<Cargos> findByCriteriaInCargos(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        ICargosLogic cargosLogic = new CargosLogic();

        return cargosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Cargos> findPageCargos(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ICargosLogic cargosLogic = new CargosLogic();

        return cargosLogic.findPageCargos(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberCargos() throws Exception {
        ICargosLogic cargosLogic = new CargosLogic();

        return cargosLogic.findTotalNumberCargos();
    }

    public static List<CcUsuario> getCcUsuario() throws Exception {
        ICcUsuarioLogic ccUsuarioLogic = new CcUsuarioLogic();

        return ccUsuarioLogic.getCcUsuario();
    }

    public static void saveCcUsuario(String codCc, String loggin )
        throws Exception {
        ICcUsuarioLogic ccUsuarioLogic = new CcUsuarioLogic();
        ccUsuarioLogic.saveCcUsuario(codCc, loggin);
    }

    public static void deleteCcUsuario(String codCc, String loggin)
        throws Exception {
        ICcUsuarioLogic ccUsuarioLogic = new CcUsuarioLogic();
        ccUsuarioLogic.deleteCcUsuario(codCc, loggin);
    }

    public static void updateCcUsuario(String codCc, String loggin)
        throws Exception {
        ICcUsuarioLogic ccUsuarioLogic = new CcUsuarioLogic();
        ccUsuarioLogic.updateCcUsuario(codCc, loggin);
    }

    public static CcUsuario getCcUsuario(CcUsuarioId id)
        throws Exception {
        ICcUsuarioLogic ccUsuarioLogic = new CcUsuarioLogic();
        CcUsuario ccUsuario = null;

        try {
            ccUsuario = ccUsuarioLogic.getCcUsuario(id);
        } catch (Exception e) {
            throw e;
        }

        return ccUsuario;
    }

    public static List<CcUsuario> findByCriteriaInCcUsuario(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ICcUsuarioLogic ccUsuarioLogic = new CcUsuarioLogic();

        return ccUsuarioLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<CcUsuario> findPageCcUsuario(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ICcUsuarioLogic ccUsuarioLogic = new CcUsuarioLogic();

        return ccUsuarioLogic.findPageCcUsuario(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberCcUsuario() throws Exception {
        ICcUsuarioLogic ccUsuarioLogic = new CcUsuarioLogic();

        return ccUsuarioLogic.findTotalNumberCcUsuario();
    }

    public static List<CentroDeCostos> getCentroDeCostos()
        throws Exception {
        ICentroDeCostosLogic centroDeCostosLogic = new CentroDeCostosLogic();

        return centroDeCostosLogic.getCentroDeCostos();
    }

    public static void saveCentroDeCostos(String codCc, String descripcion)
        throws Exception {
        ICentroDeCostosLogic centroDeCostosLogic = new CentroDeCostosLogic();
        centroDeCostosLogic.saveCentroDeCostos(codCc, descripcion);
    }

    public static void deleteCentroDeCostos(String codCc)
        throws Exception {
        ICentroDeCostosLogic centroDeCostosLogic = new CentroDeCostosLogic();
        centroDeCostosLogic.deleteCentroDeCostos(codCc);
    }

    public static void updateCentroDeCostos(String codCc, String descripcion)
        throws Exception {
        ICentroDeCostosLogic centroDeCostosLogic = new CentroDeCostosLogic();
        centroDeCostosLogic.updateCentroDeCostos(codCc, descripcion);
    }

    public static CentroDeCostos getCentroDeCostos(String codCc)
        throws Exception {
        ICentroDeCostosLogic centroDeCostosLogic = new CentroDeCostosLogic();
        CentroDeCostos centroDeCostos = null;

        try {
            centroDeCostos = centroDeCostosLogic.getCentroDeCostos(codCc);
        } catch (Exception e) {
            throw e;
        }

        return centroDeCostos;
    }

    public static List<CentroDeCostos> findByCriteriaInCentroDeCostos(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ICentroDeCostosLogic centroDeCostosLogic = new CentroDeCostosLogic();

        return centroDeCostosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<CentroDeCostos> findPageCentroDeCostos(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ICentroDeCostosLogic centroDeCostosLogic = new CentroDeCostosLogic();

        return centroDeCostosLogic.findPageCentroDeCostos(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberCentroDeCostos()
        throws Exception {
        ICentroDeCostosLogic centroDeCostosLogic = new CentroDeCostosLogic();

        return centroDeCostosLogic.findTotalNumberCentroDeCostos();
    }

    public static List<ClaseAlimento> getClaseAlimento()
        throws Exception {
        IClaseAlimentoLogic claseAlimentoLogic = new ClaseAlimentoLogic();

        return claseAlimentoLogic.getClaseAlimento();
    }

    public static void saveClaseAlimento(String codCAlimento,String descripcion)
        throws Exception {
        IClaseAlimentoLogic claseAlimentoLogic = new ClaseAlimentoLogic();
        claseAlimentoLogic.saveClaseAlimento(codCAlimento,descripcion);
    }

    public static void deleteClaseAlimento(String codCAlimento)
        throws Exception {
        IClaseAlimentoLogic claseAlimentoLogic = new ClaseAlimentoLogic();
        claseAlimentoLogic.deleteClaseAlimento(codCAlimento);
    }

    public static void updateClaseAlimento(String codCAlimento,String descripcion)
        throws Exception {
        IClaseAlimentoLogic claseAlimentoLogic = new ClaseAlimentoLogic();
        claseAlimentoLogic.updateClaseAlimento(codCAlimento,descripcion);
    }

    public static ClaseAlimento getClaseAlimento(String codCAlimento)
        throws Exception {
        IClaseAlimentoLogic claseAlimentoLogic = new ClaseAlimentoLogic();
        ClaseAlimento claseAlimento = null;

        try {
            claseAlimento = claseAlimentoLogic.getClaseAlimento(codCAlimento);
        } catch (Exception e) {
            throw e;
        }

        return claseAlimento;
    }

    public static List<ClaseAlimento> findByCriteriaInClaseAlimento(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IClaseAlimentoLogic claseAlimentoLogic = new ClaseAlimentoLogic();

        return claseAlimentoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<ClaseAlimento> findPageClaseAlimento(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IClaseAlimentoLogic claseAlimentoLogic = new ClaseAlimentoLogic();

        return claseAlimentoLogic.findPageClaseAlimento(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberClaseAlimento() throws Exception {
        IClaseAlimentoLogic claseAlimentoLogic = new ClaseAlimentoLogic();

        return claseAlimentoLogic.findTotalNumberClaseAlimento();
    }

    public static List<ComposicionSala> getComposicionSala()
        throws Exception {
        IComposicionSalaLogic composicionSalaLogic = new ComposicionSalaLogic();

        return composicionSalaLogic.getComposicionSala();
    }

    public static void saveComposicionSala(String codCompsala, String codSala
       ) throws Exception {
        IComposicionSalaLogic composicionSalaLogic = new ComposicionSalaLogic();
        composicionSalaLogic.saveComposicionSala(codCompsala, codSala
            );
    }

    public static void deleteComposicionSala(String codCompsala, String codSala)
        throws Exception {
        IComposicionSalaLogic composicionSalaLogic = new ComposicionSalaLogic();
        composicionSalaLogic.deleteComposicionSala(codCompsala, codSala);
    }

    public static void updateComposicionSala(String codCompsala,
        String codSala) throws Exception {
        IComposicionSalaLogic composicionSalaLogic = new ComposicionSalaLogic();
        composicionSalaLogic.updateComposicionSala(codCompsala, codSala
            );
    }

    public static ComposicionSala getComposicionSala(ComposicionSalaId id)
        throws Exception {
        IComposicionSalaLogic composicionSalaLogic = new ComposicionSalaLogic();
        ComposicionSala composicionSala = null;

        try {
            composicionSala = composicionSalaLogic.getComposicionSala(id);
        } catch (Exception e) {
            throw e;
        }

        return composicionSala;
    }

    public static List<ComposicionSala> findByCriteriaInComposicionSala(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IComposicionSalaLogic composicionSalaLogic = new ComposicionSalaLogic();

        return composicionSalaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<ComposicionSala> findPageComposicionSala(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IComposicionSalaLogic composicionSalaLogic = new ComposicionSalaLogic();

        return composicionSalaLogic.findPageComposicionSala(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberComposicionSala()
        throws Exception {
        IComposicionSalaLogic composicionSalaLogic = new ComposicionSalaLogic();

        return composicionSalaLogic.findTotalNumberComposicionSala();
    }

    public static List<Departamentos> getDepartamentos()
        throws Exception {
        IDepartamentosLogic departamentosLogic = new DepartamentosLogic();

        return departamentosLogic.getDepartamentos();
    }

    public static void saveDepartamentos(String codDepat, String codEntidad,
        BigDecimal codEntidad_Entidades) throws Exception {
        IDepartamentosLogic departamentosLogic = new DepartamentosLogic();
        departamentosLogic.saveDepartamentos(codDepat, codEntidad,
            codEntidad_Entidades.toString());
    }

    public static void deleteDepartamentos(String codDepat, BigDecimal codEntidad)
        throws Exception {
        IDepartamentosLogic departamentosLogic = new DepartamentosLogic();
        departamentosLogic.deleteDepartamentos(codDepat, codEntidad.toString());
    }

    public static void updateDepartamentos(String codDepat, String codEntidad,
        String codEntidad_Entidades) throws Exception {
        IDepartamentosLogic departamentosLogic = new DepartamentosLogic();
        departamentosLogic.updateDepartamentos(codDepat, codEntidad,
            codEntidad_Entidades);
    }

    public static Departamentos getDepartamentos(DepartamentosId id)
        throws Exception {
        IDepartamentosLogic departamentosLogic = new DepartamentosLogic();
        Departamentos departamentos = null;

        try {
            departamentos = departamentosLogic.getDepartamentos(id);
        } catch (Exception e) {
            throw e;
        }

        return departamentos;
    }

    public static List<Departamentos> findByCriteriaInDepartamentos(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IDepartamentosLogic departamentosLogic = new DepartamentosLogic();

        return departamentosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Departamentos> findPageDepartamentos(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IDepartamentosLogic departamentosLogic = new DepartamentosLogic();

        return departamentosLogic.findPageDepartamentos(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberDepartamentos() throws Exception {
        IDepartamentosLogic departamentosLogic = new DepartamentosLogic();

        return departamentosLogic.findTotalNumberDepartamentos();
    }

    public static List<ElemAudiovisuales> getElemAudiovisuales()
        throws Exception {
        IElemAudiovisualesLogic elemAudiovisualesLogic = new ElemAudiovisualesLogic();

        return elemAudiovisualesLogic.getElemAudiovisuales();
    }

    public static void saveElemAudiovisuales(String codElem,
        String codReservas)
        throws Exception {
        IElemAudiovisualesLogic elemAudiovisualesLogic = new ElemAudiovisualesLogic();
        elemAudiovisualesLogic.saveElemAudiovisuales(codElem, codReservas);
    }

    public static void deleteElemAudiovisuales(String codElem,
        String codReservas) throws Exception {
        IElemAudiovisualesLogic elemAudiovisualesLogic = new ElemAudiovisualesLogic();
        elemAudiovisualesLogic.deleteElemAudiovisuales(codElem, codReservas);
    }

    public static void updateElemAudiovisuales(String codElem,
        String codReservas, String codReservas_Reservas)
        throws Exception {
        IElemAudiovisualesLogic elemAudiovisualesLogic = new ElemAudiovisualesLogic();
        elemAudiovisualesLogic.updateElemAudiovisuales(codElem, codReservas,
            codReservas_Reservas);
    }

    public static ElemAudiovisuales getElemAudiovisuales(ElemAudiovisualesId id)
        throws Exception {
        IElemAudiovisualesLogic elemAudiovisualesLogic = new ElemAudiovisualesLogic();
        ElemAudiovisuales elemAudiovisuales = null;

        try {
            elemAudiovisuales = elemAudiovisualesLogic.getElemAudiovisuales(id);
        } catch (Exception e) {
            throw e;
        }

        return elemAudiovisuales;
    }

    public static List<ElemAudiovisuales> findByCriteriaInElemAudiovisuales(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IElemAudiovisualesLogic elemAudiovisualesLogic = new ElemAudiovisualesLogic();

        return elemAudiovisualesLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<ElemAudiovisuales> findPageElemAudiovisuales(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IElemAudiovisualesLogic elemAudiovisualesLogic = new ElemAudiovisualesLogic();

        return elemAudiovisualesLogic.findPageElemAudiovisuales(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberElemAudiovisuales()
        throws Exception {
        IElemAudiovisualesLogic elemAudiovisualesLogic = new ElemAudiovisualesLogic();

        return elemAudiovisualesLogic.findTotalNumberElemAudiovisuales();
    }

    public static List<Entidades> getEntidades() throws Exception {
        IEntidadesLogic entidadesLogic = new EntidadesLogic();

        return entidadesLogic.getEntidades();
    }

    public static void saveEntidades(String codEntidad,String nombre)
        throws Exception {
        IEntidadesLogic entidadesLogic = new EntidadesLogic();
        entidadesLogic.saveEntidades(codEntidad,nombre);
    }

    public static void deleteEntidades(String codEntidad)
        throws Exception {
        IEntidadesLogic entidadesLogic = new EntidadesLogic();
        entidadesLogic.deleteEntidades(codEntidad);
    }

    public static void updateEntidades(String codEntidad,String nombre)
        throws Exception {
        IEntidadesLogic entidadesLogic = new EntidadesLogic();
        entidadesLogic.updateEntidades(codEntidad,nombre);
    }

    public static Entidades getEntidades(String codEntidad)
        throws Exception {
        IEntidadesLogic entidadesLogic = new EntidadesLogic();
        Entidades entidades = null;

        try {
            entidades = entidadesLogic.getEntidades(codEntidad);
        } catch (Exception e) {
            throw e;
        }

        return entidades;
    }

    public static List<Entidades> findByCriteriaInEntidades(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IEntidadesLogic entidadesLogic = new EntidadesLogic();

        return entidadesLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Entidades> findPageEntidades(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IEntidadesLogic entidadesLogic = new EntidadesLogic();

        return entidadesLogic.findPageEntidades(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberEntidades() throws Exception {
        IEntidadesLogic entidadesLogic = new EntidadesLogic();

        return entidadesLogic.findTotalNumberEntidades();
    }

    public static List<Funcionarios> getFuncionarios()
        throws Exception {
        IFuncionariosLogic funcionariosLogic = new FuncionariosLogic();

        return funcionariosLogic.getFuncionarios();
    }

    public static void saveFuncionarios(Long cedula, String email,
        String estado, Date fechaRegistro, Date fechaRetiro,
        BigDecimal codCargo, String codSubarea,
        String nombre, String seccion,
        String departamento,String entidad) throws Exception {
        IFuncionariosLogic funcionariosLogic = new FuncionariosLogic();
        funcionariosLogic.saveFuncionarios(cedula, email, estado,
            fechaRegistro, fechaRetiro, codCargo.toString(), codSubarea,
            nombre, seccion, departamento,entidad);
    }

    public static void deleteFuncionarios(Long cedula)
        throws Exception {
        IFuncionariosLogic funcionariosLogic = new FuncionariosLogic();
        funcionariosLogic.deleteFuncionarios(cedula);
    }

    public static void updateFuncionarios(Long cedula, String email,
            String estado, Date fechaRegistro, Date fechaRetiro,
            BigDecimal codCargo, String codSubarea,
            String nombre, String seccion,
            String departamento,String entidad) throws Exception {
        IFuncionariosLogic funcionariosLogic = new FuncionariosLogic();
        funcionariosLogic.updateFuncionarios(cedula, email, estado,
            fechaRegistro, fechaRetiro,codCargo.toString(), codSubarea,
            nombre, seccion,departamento,entidad);
    }

    public static Funcionarios getFuncionarios(Long cedula)
        throws Exception {
        IFuncionariosLogic funcionariosLogic = new FuncionariosLogic();
        Funcionarios funcionarios = null;

        try {
            funcionarios = funcionariosLogic.getFuncionarios(cedula);
        } catch (Exception e) {
            throw e;
        }

        return funcionarios;
    }

    public static List<Funcionarios> findByCriteriaInFuncionarios(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IFuncionariosLogic funcionariosLogic = new FuncionariosLogic();

        return funcionariosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Funcionarios> findPageFuncionarios(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IFuncionariosLogic funcionariosLogic = new FuncionariosLogic();

        return funcionariosLogic.findPageFuncionarios(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberFuncionarios() throws Exception {
        IFuncionariosLogic funcionariosLogic = new FuncionariosLogic();

        return funcionariosLogic.findTotalNumberFuncionarios();
    }

    public static List<HorarioRxsala> getHorarioRxsala()
        throws Exception {
        IHorarioRxsalaLogic horarioRxsalaLogic = new HorarioRxsalaLogic();

        return horarioRxsalaLogic.getHorarioRxsala();
    }

 /*   public static void saveHorarioRxsala(String codReservas,
        String consecutivo, String codSala, Date fechaEvento,
        String codReservas_Reservas, String codSala_Salas)
        throws Exception {
        IHorarioRxsalaLogic horarioRxsalaLogic = new HorarioRxsalaLogic();
        horarioRxsalaLogic.saveHorarioRxsala(codReservas, consecutivo, codSala,
            fechaEvento, codReservas_Reservas, codSala_Salas);
    }*/
    public static void saveHorarioRxsala(String codReservas,
            String rhConsecutivo, BigDecimal codSala, Date fechaEvento)
            throws Exception {
            IHorarioRxsalaLogic horarioRxsalaLogic = new HorarioRxsalaLogic();
            horarioRxsalaLogic.saveHorarioRxsala(codReservas, rhConsecutivo,
                codSala.toString(), fechaEvento);
        }

    public static void deleteHorarioRxsala(String codReservas,
        String consecutivo, String codSala, Date fechaEvento)
        throws Exception {
        IHorarioRxsalaLogic horarioRxsalaLogic = new HorarioRxsalaLogic();
        horarioRxsalaLogic.deleteHorarioRxsala(codReservas, consecutivo,
            codSala, fechaEvento);
    }

    public static void updateHorarioRxsala(String codReservas,
        String consecutivo, String codSala, Date fechaEvento,
        String codReservas_Reservas, String codSala_Salas)
        throws Exception {
        IHorarioRxsalaLogic horarioRxsalaLogic = new HorarioRxsalaLogic();
        horarioRxsalaLogic.updateHorarioRxsala(codReservas, consecutivo,
            codSala, fechaEvento, codReservas_Reservas, codSala_Salas);
    }

    public static HorarioRxsala getHorarioRxsala(HorarioRxsalaId id)
        throws Exception {
        IHorarioRxsalaLogic horarioRxsalaLogic = new HorarioRxsalaLogic();
        HorarioRxsala horarioRxsala = null;

        try {
            horarioRxsala = horarioRxsalaLogic.getHorarioRxsala(id);
        } catch (Exception e) {
            throw e;
        }

        return horarioRxsala;
    }

    public static List<HorarioRxsala> findByCriteriaInHorarioRxsala(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IHorarioRxsalaLogic horarioRxsalaLogic = new HorarioRxsalaLogic();

        return horarioRxsalaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<HorarioRxsala> findPageHorarioRxsala(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IHorarioRxsalaLogic horarioRxsalaLogic = new HorarioRxsalaLogic();

        return horarioRxsalaLogic.findPageHorarioRxsala(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberHorarioRxsala() throws Exception {
        IHorarioRxsalaLogic horarioRxsalaLogic = new HorarioRxsalaLogic();

        return horarioRxsalaLogic.findTotalNumberHorarioRxsala();
    }

    public static List<ImagenFormas> getImagenFormas()
        throws Exception {
        IImagenFormasLogic imagenFormasLogic = new ImagenFormasLogic();

        return imagenFormasLogic.getImagenFormas();
    }

    public static void saveImagenFormas(String codImagen,byte[] imagen)
        throws Exception {
        IImagenFormasLogic imagenFormasLogic = new ImagenFormasLogic();
        imagenFormasLogic.saveImagenFormas(codImagen,imagen);
    }

    public static void deleteImagenFormas(String codImagen)
        throws Exception {
        IImagenFormasLogic imagenFormasLogic = new ImagenFormasLogic();
        imagenFormasLogic.deleteImagenFormas(codImagen);
    }

    public static void updateImagenFormas(String codImagen,byte[] imagen)
        throws Exception {
        IImagenFormasLogic imagenFormasLogic = new ImagenFormasLogic();
        imagenFormasLogic.updateImagenFormas(codImagen,imagen);
    }

    public static ImagenFormas getImagenFormas(String codImagen)
        throws Exception {
        IImagenFormasLogic imagenFormasLogic = new ImagenFormasLogic();
        ImagenFormas imagenFormas = null;

        try {
            imagenFormas = imagenFormasLogic.getImagenFormas(codImagen);
        } catch (Exception e) {
            throw e;
        }

        return imagenFormas;
    }

    public static List<ImagenFormas> findByCriteriaInImagenFormas(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IImagenFormasLogic imagenFormasLogic = new ImagenFormasLogic();

        return imagenFormasLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<ImagenFormas> findPageImagenFormas(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IImagenFormasLogic imagenFormasLogic = new ImagenFormasLogic();

        return imagenFormasLogic.findPageImagenFormas(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberImagenFormas() throws Exception {
        IImagenFormasLogic imagenFormasLogic = new ImagenFormasLogic();

        return imagenFormasLogic.findTotalNumberImagenFormas();
    }

    public static List<ProSerOfrecen> getProSerOfrecen()
        throws Exception {
        IProSerOfrecenLogic proSerOfrecenLogic = new ProSerOfrecenLogic();

        return proSerOfrecenLogic.getProSerOfrecen();
    }

  /*  public static void saveProSerOfrecen(String codProvee, String codSerO,
        String codProvee_Proveedores, String codSerO_SerOfrecen)
        throws Exception {
        IProSerOfrecenLogic proSerOfrecenLogic = new ProSerOfrecenLogic();
        proSerOfrecenLogic.saveProSerOfrecen(codProvee, codSerO,
            codProvee_Proveedores, codSerO_SerOfrecen);
    }*/
    
    public static void saveProSerOfrecen(String codProvee, String codSerO)
    throws Exception {
    IProSerOfrecenLogic proSerOfrecenLogic = new ProSerOfrecenLogic();
    proSerOfrecenLogic.saveProSerOfrecen(codProvee, codSerO);
}

    public static void deleteProSerOfrecen(String codProvee, String codSerO)
        throws Exception {
        IProSerOfrecenLogic proSerOfrecenLogic = new ProSerOfrecenLogic();
        proSerOfrecenLogic.deleteProSerOfrecen(codProvee, codSerO);
    }

    public static void updateProSerOfrecen(String codProvee, String codSerO,
        String codProvee_Proveedores, String codSerO_SerOfrecen)
        throws Exception {
        IProSerOfrecenLogic proSerOfrecenLogic = new ProSerOfrecenLogic();
        proSerOfrecenLogic.updateProSerOfrecen(codProvee, codSerO,
            codProvee_Proveedores, codSerO_SerOfrecen);
    }

    public static ProSerOfrecen getProSerOfrecen(ProSerOfrecenId id)
        throws Exception {
        IProSerOfrecenLogic proSerOfrecenLogic = new ProSerOfrecenLogic();
        ProSerOfrecen proSerOfrecen = null;

        try {
            proSerOfrecen = proSerOfrecenLogic.getProSerOfrecen(id);
        } catch (Exception e) {
            throw e;
        }

        return proSerOfrecen;
    }

    public static List<ProSerOfrecen> findByCriteriaInProSerOfrecen(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IProSerOfrecenLogic proSerOfrecenLogic = new ProSerOfrecenLogic();

        return proSerOfrecenLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<ProSerOfrecen> findPageProSerOfrecen(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IProSerOfrecenLogic proSerOfrecenLogic = new ProSerOfrecenLogic();

        return proSerOfrecenLogic.findPageProSerOfrecen(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberProSerOfrecen() throws Exception {
        IProSerOfrecenLogic proSerOfrecenLogic = new ProSerOfrecenLogic();

        return proSerOfrecenLogic.findTotalNumberProSerOfrecen();
    }

    public static List<Proveedores> getProveedores() throws Exception {
        IProveedoresLogic proveedoresLogic = new ProveedoresLogic();

        return proveedoresLogic.getProveedores();
    }

    public static void saveProveedores(String codProvee, String email, Long nit,BigDecimal codTipoProvee,String Nombre,String direccion,String ciudad,Long telefono,Long fax,String persona,String estado)
    throws Exception {
    IProveedoresLogic proveedoresLogic = new ProveedoresLogic();
    proveedoresLogic.saveProveedores(codProvee, email, nit,codTipoProvee.toString(),Nombre,direccion,ciudad,telefono,fax,persona,estado);
}

    public static void deleteProveedores(String codProvee)
        throws Exception {
        IProveedoresLogic proveedoresLogic = new ProveedoresLogic();
        proveedoresLogic.deleteProveedores(codProvee);
    }

    public static void updateProveedores(String codProvee, String email,
            Long nit,BigDecimal codTipoProve,String Nombre,String dirrecion,String ciudad,Long telefono,Long fax,String persona,String estado) throws Exception {
            IProveedoresLogic proveedoresLogic = new ProveedoresLogic();
            proveedoresLogic.updateProveedores(codProvee, email, nit,codTipoProve.toString(),Nombre,dirrecion,ciudad,telefono,fax,persona,estado);
        }
    public static Proveedores getProveedores(String codProvee)
        throws Exception {
        IProveedoresLogic proveedoresLogic = new ProveedoresLogic();
        Proveedores proveedores = null;

        try {
            proveedores = proveedoresLogic.getProveedores(codProvee);
        } catch (Exception e) {
            throw e;
        }

        return proveedores;
    }

    public static List<Proveedores> findByCriteriaInProveedores(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IProveedoresLogic proveedoresLogic = new ProveedoresLogic();

        return proveedoresLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Proveedores> findPageProveedores(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IProveedoresLogic proveedoresLogic = new ProveedoresLogic();

        return proveedoresLogic.findPageProveedores(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberProveedores() throws Exception {
        IProveedoresLogic proveedoresLogic = new ProveedoresLogic();

        return proveedoresLogic.findTotalNumberProveedores();
    }

    public static List<RDRequerimientos> getRDRequerimientos()
        throws Exception {
        IRDRequerimientosLogic rDRequerimientosLogic = new RDRequerimientosLogic();

        return rDRequerimientosLogic.getRDRequerimientos();
    }

    public static void saveRDRequerimientos(String consecuti, String reNombre) throws Exception {
        IRDRequerimientosLogic rDRequerimientosLogic = new RDRequerimientosLogic();
        rDRequerimientosLogic.saveRDRequerimientos(consecuti,reNombre);
    }

    public static void deleteRDRequerimientos(String codRequerimientos)
        throws Exception {
        IRDRequerimientosLogic rDRequerimientosLogic = new RDRequerimientosLogic();
        rDRequerimientosLogic.deleteRDRequerimientos(codRequerimientos);
    }

    public static void updateRDRequerimientos(String codRequerimientos,
        String reNombre) throws Exception {
        IRDRequerimientosLogic rDRequerimientosLogic = new RDRequerimientosLogic();
        rDRequerimientosLogic.updateRDRequerimientos(codRequerimientos, reNombre);
    }

    public static RDRequerimientos getRDRequerimientos(String codRequerimientos)
        throws Exception {
        IRDRequerimientosLogic rDRequerimientosLogic = new RDRequerimientosLogic();
        RDRequerimientos rDRequerimientos = null;

        try {
            rDRequerimientos = rDRequerimientosLogic.getRDRequerimientos(codRequerimientos);
        } catch (Exception e) {
            throw e;
        }

        return rDRequerimientos;
    }

    public static List<RDRequerimientos> findByCriteriaInRDRequerimientos(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IRDRequerimientosLogic rDRequerimientosLogic = new RDRequerimientosLogic();

        return rDRequerimientosLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<RDRequerimientos> findPageRDRequerimientos(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IRDRequerimientosLogic rDRequerimientosLogic = new RDRequerimientosLogic();

        return rDRequerimientosLogic.findPageRDRequerimientos(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberRDRequerimientos()
        throws Exception {
        IRDRequerimientosLogic rDRequerimientosLogic = new RDRequerimientosLogic();

        return rDRequerimientosLogic.findTotalNumberRDRequerimientos();
    }

    public static List<Reservas> getReservas() throws Exception {
        IReservasLogic reservasLogic = new ReservasLogic();

        return reservasLogic.getReservas();
    }

 /*   public static void saveReservas(String codReservas, Date fechaEvento,
        Date fechaReserva, String codSala_Salaxtforma,
        String codTforma_Salaxtforma, String codSolicitude_SolEventos,
        String loggin_Usuarios) throws Exception {
        IReservasLogic reservasLogic = new ReservasLogic();
        reservasLogic.saveReservas(codReservas, fechaEvento, fechaReserva,
            codSala_Salaxtforma, codTforma_Salaxtforma,
            codSolicitude_SolEventos, loggin_Usuarios);
    }*/
    
    public static void saveReservas(String codReservas, Date fechaEvento,
            Date fechaReserva, BigDecimal sfCodSala_Salaxtforma,
            BigDecimal sfCodTforma_Salaxtforma,
            String loggin_Usuarios,String numeroSolic,Long numeParti,String cuenta) throws Exception {
            IReservasLogic reservasLogic = new ReservasLogic();
            reservasLogic.saveReservas(codReservas, fechaEvento, fechaReserva,
                sfCodSala_Salaxtforma.toString(),sfCodTforma_Salaxtforma.toString(),
                 loggin_Usuarios,numeroSolic,numeParti,cuenta);
        }

    public static void deleteReservas(String codReservas)
        throws Exception {
        IReservasLogic reservasLogic = new ReservasLogic();
        reservasLogic.deleteReservas(codReservas);
    }

    public static void updateReservas(String codReservas, Date fechaEvento,
            Date fechaReserva, BigDecimal sfCodSala_Salaxtforma,
            BigDecimal sfCodTforma_Salaxtforma,
            String loggin_Usuarios,String numeroSolic,Long numeParti,String cuenta) throws Exception {
        IReservasLogic reservasLogic = new ReservasLogic();
        reservasLogic.updateReservas(codReservas, fechaEvento, fechaReserva,
                sfCodSala_Salaxtforma.toString(),sfCodTforma_Salaxtforma.toString(),
                loggin_Usuarios,numeroSolic,numeParti,cuenta);
    }

    public static Reservas getReservas(String codReservas)
        throws Exception {
        IReservasLogic reservasLogic = new ReservasLogic();
        Reservas reservas = null;

        try {
            reservas = reservasLogic.getReservas(codReservas);
        } catch (Exception e) {
            throw e;
        }

        return reservas;
    }

    public static List<Reservas> findByCriteriaInReservas(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IReservasLogic reservasLogic = new ReservasLogic();

        return reservasLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Reservas> findPageReservas(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IReservasLogic reservasLogic = new ReservasLogic();

        return reservasLogic.findPageReservas(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberReservas() throws Exception {
        IReservasLogic reservasLogic = new ReservasLogic();

        return reservasLogic.findTotalNumberReservas();
    }

    public static List<Reservaxrequerimient> getReservaxrequerimient()
        throws Exception {
        IReservaxrequerimientLogic reservaxrequerimientLogic = new ReservaxrequerimientLogic();

        return reservaxrequerimientLogic.getReservaxrequerimient();
    }

    public static void saveReservaxrequerimient(Long concecutivo,
        String codReservaxrequerimiento, String codSolicitude_SolEventos)
        throws Exception {
        IReservaxrequerimientLogic reservaxrequerimientLogic = new ReservaxrequerimientLogic();
        reservaxrequerimientLogic.saveReservaxrequerimient(concecutivo.toString(),codReservaxrequerimiento,
            codSolicitude_SolEventos);
    }

    public static void deleteReservaxrequerimient(
        String codReservaxrequerimiento) throws Exception {
        IReservaxrequerimientLogic reservaxrequerimientLogic = new ReservaxrequerimientLogic();
        reservaxrequerimientLogic.deleteReservaxrequerimient(codReservaxrequerimiento);
    }

    public static void updateReservaxrequerimient(
        String codReservaxrequerimiento, String codSolicitude_SolEventos)
        throws Exception {
        IReservaxrequerimientLogic reservaxrequerimientLogic = new ReservaxrequerimientLogic();
        reservaxrequerimientLogic.updateReservaxrequerimient(codReservaxrequerimiento,
            codSolicitude_SolEventos);
    }

    public static Reservaxrequerimient getReservaxrequerimient(
        String codReservaxrequerimiento) throws Exception {
        IReservaxrequerimientLogic reservaxrequerimientLogic = new ReservaxrequerimientLogic();
        Reservaxrequerimient reservaxrequerimient = null;

        try {
            reservaxrequerimient = reservaxrequerimientLogic.getReservaxrequerimient(codReservaxrequerimiento);
        } catch (Exception e) {
            throw e;
        }

        return reservaxrequerimient;
    }

    public static List<Reservaxrequerimient> findByCriteriaInReservaxrequerimient(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IReservaxrequerimientLogic reservaxrequerimientLogic = new ReservaxrequerimientLogic();

        return reservaxrequerimientLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<Reservaxrequerimient> findPageReservaxrequerimient(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IReservaxrequerimientLogic reservaxrequerimientLogic = new ReservaxrequerimientLogic();

        return reservaxrequerimientLogic.findPageReservaxrequerimient(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberReservaxrequerimient()
        throws Exception {
        IReservaxrequerimientLogic reservaxrequerimientLogic = new ReservaxrequerimientLogic();

        return reservaxrequerimientLogic.findTotalNumberReservaxrequerimient();
    }

    public static List<Restaurantes> getRestaurantes()
        throws Exception {
        IRestaurantesLogic restaurantesLogic = new RestaurantesLogic();

        return restaurantesLogic.getRestaurantes();
    }

    public static void saveRestaurantes(String codResta, String estado,
        String resNosmbre, Long resValorAlimento) throws Exception {
        IRestaurantesLogic restaurantesLogic = new RestaurantesLogic();
        restaurantesLogic.saveRestaurantes(codResta, estado, resNosmbre,
            resValorAlimento);
    }

    public static void deleteRestaurantes(String codResta)
        throws Exception {
        IRestaurantesLogic restaurantesLogic = new RestaurantesLogic();
        restaurantesLogic.deleteRestaurantes(codResta);
    }

    public static void updateRestaurantes(String codResta, String estado,
        String resNosmbre, Long resValorAlimento) throws Exception {
        IRestaurantesLogic restaurantesLogic = new RestaurantesLogic();
        restaurantesLogic.updateRestaurantes(codResta, estado, resNosmbre,
            resValorAlimento);
    }

    public static Restaurantes getRestaurantes(String codResta)
        throws Exception {
        IRestaurantesLogic restaurantesLogic = new RestaurantesLogic();
        Restaurantes restaurantes = null;

        try {
            restaurantes = restaurantesLogic.getRestaurantes(codResta);
        } catch (Exception e) {
            throw e;
        }

        return restaurantes;
    }

    public static List<Restaurantes> findByCriteriaInRestaurantes(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IRestaurantesLogic restaurantesLogic = new RestaurantesLogic();

        return restaurantesLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Restaurantes> findPageRestaurantes(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IRestaurantesLogic restaurantesLogic = new RestaurantesLogic();

        return restaurantesLogic.findPageRestaurantes(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberRestaurantes() throws Exception {
        IRestaurantesLogic restaurantesLogic = new RestaurantesLogic();

        return restaurantesLogic.findTotalNumberRestaurantes();
    }

    public static List<RHorariosReserva> getRHorariosReserva()
        throws Exception {
        IRHorariosReservaLogic rHorariosReservaLogic = new RHorariosReservaLogic();

        return rHorariosReservaLogic.getRHorariosReserva();
    }

    public static void saveRHorariosReserva(String consecutivo,String HInicio)
        throws Exception {
        IRHorariosReservaLogic rHorariosReservaLogic = new RHorariosReservaLogic();
        rHorariosReservaLogic.saveRHorariosReserva(consecutivo,HInicio);
    }

    public static void deleteRHorariosReserva(String consecutivo)
        throws Exception {
        IRHorariosReservaLogic rHorariosReservaLogic = new RHorariosReservaLogic();
        rHorariosReservaLogic.deleteRHorariosReserva(consecutivo);
    }

    public static void updateRHorariosReserva(String consecutivo,String Hini_Hfin)
        throws Exception {
        IRHorariosReservaLogic rHorariosReservaLogic = new RHorariosReservaLogic();
        rHorariosReservaLogic.updateRHorariosReserva(consecutivo,Hini_Hfin);
    }

    public static RHorariosReserva getRHorariosReserva(String consecutivo)
        throws Exception {
        IRHorariosReservaLogic rHorariosReservaLogic = new RHorariosReservaLogic();
        RHorariosReserva rHorariosReserva = null;

        try {
            rHorariosReserva = rHorariosReservaLogic.getRHorariosReserva(consecutivo);
        } catch (Exception e) {
            throw e;
        }

        return rHorariosReserva;
    }

    public static List<RHorariosReserva> findByCriteriaInRHorariosReserva(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IRHorariosReservaLogic rHorariosReservaLogic = new RHorariosReservaLogic();

        return rHorariosReservaLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<RHorariosReserva> findPageRHorariosReserva(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IRHorariosReservaLogic rHorariosReservaLogic = new RHorariosReservaLogic();

        return rHorariosReservaLogic.findPageRHorariosReserva(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberRHorariosReserva()
        throws Exception {
        IRHorariosReservaLogic rHorariosReservaLogic = new RHorariosReservaLogic();

        return rHorariosReservaLogic.findTotalNumberRHorariosReserva();
    }

    public static List<Salas> getSalas() throws Exception {
        ISalasLogic salasLogic = new SalasLogic();

        return salasLogic.getSalas();
    }

    public static void saveSalas(String codSala, String estado,String descripcion)
        throws Exception {
        ISalasLogic salasLogic = new SalasLogic();
        salasLogic.saveSalas(codSala, estado,descripcion);
    }

    public static void deleteSalas(String codSala) throws Exception {
        ISalasLogic salasLogic = new SalasLogic();
        salasLogic.deleteSalas(codSala);
    }

    public static void updateSalas(String codSala, String estado,String descripcion)
        throws Exception {
        ISalasLogic salasLogic = new SalasLogic();
        salasLogic.updateSalas(codSala, estado,descripcion);
    }

    public static Salas getSalas(String codSala) throws Exception {
        ISalasLogic salasLogic = new SalasLogic();
        Salas salas = null;

        try {
            salas = salasLogic.getSalas(codSala);
        } catch (Exception e) {
            throw e;
        }

        return salas;
    }

    public static List<Salas> findByCriteriaInSalas(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        ISalasLogic salasLogic = new SalasLogic();

        return salasLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Salas> findPageSalas(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ISalasLogic salasLogic = new SalasLogic();

        return salasLogic.findPageSalas(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberSalas() throws Exception {
        ISalasLogic salasLogic = new SalasLogic();

        return salasLogic.findTotalNumberSalas();
    }

    public static List<Salasxusuarios> getSalasxusuarios()
        throws Exception {
        ISalasxusuariosLogic salasxusuariosLogic = new SalasxusuariosLogic();

        return salasxusuariosLogic.getSalasxusuarios();
    }

    public static void saveSalasxusuarios(String codSala, String loggin
        ) throws Exception {
        ISalasxusuariosLogic salasxusuariosLogic = new SalasxusuariosLogic();
        salasxusuariosLogic.saveSalasxusuarios(codSala.toString(), loggin);
    }

    public static void deleteSalasxusuarios(String codSala, String loggin)
        throws Exception {
        ISalasxusuariosLogic salasxusuariosLogic = new SalasxusuariosLogic();
        salasxusuariosLogic.deleteSalasxusuarios(codSala, loggin);
    }

    public static void updateSalasxusuarios(String codSala, String loggin
      ) throws Exception {
        ISalasxusuariosLogic salasxusuariosLogic = new SalasxusuariosLogic();
        salasxusuariosLogic.updateSalasxusuarios(codSala, loggin );
    }

    public static Salasxusuarios getSalasxusuarios(SalasxusuariosId id)
        throws Exception {
        ISalasxusuariosLogic salasxusuariosLogic = new SalasxusuariosLogic();
        Salasxusuarios salasxusuarios = null;

        try {
            salasxusuarios = salasxusuariosLogic.getSalasxusuarios(id);
        } catch (Exception e) {
            throw e;
        }

        return salasxusuarios;
    }

    public static List<Salasxusuarios> findByCriteriaInSalasxusuarios(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ISalasxusuariosLogic salasxusuariosLogic = new SalasxusuariosLogic();

        return salasxusuariosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Salasxusuarios> findPageSalasxusuarios(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ISalasxusuariosLogic salasxusuariosLogic = new SalasxusuariosLogic();

        return salasxusuariosLogic.findPageSalasxusuarios(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberSalasxusuarios()
        throws Exception {
        ISalasxusuariosLogic salasxusuariosLogic = new SalasxusuariosLogic();

        return salasxusuariosLogic.findTotalNumberSalasxusuarios();
    }

    public static List<Salaxtforma> getSalaxtforma() throws Exception {
        ISalaxtformaLogic salaxtformaLogic = new SalaxtformaLogic();

        return salaxtformaLogic.getSalaxtforma();
    }

    public static void saveSalaxtforma(BigDecimal codSala,String codTforma,
        Long capacidad) throws Exception {
        ISalaxtformaLogic salaxtformaLogic = new SalaxtformaLogic();
        salaxtformaLogic.saveSalaxtforma(codSala.toString(), codTforma.toString(), capacidad);
    }

    public static void deleteSalaxtforma(String codSala, String codTforma)
        throws Exception {
        ISalaxtformaLogic salaxtformaLogic = new SalaxtformaLogic();
        salaxtformaLogic.deleteSalaxtforma(codSala, codTforma);
    }

    public static void updateSalaxtforma(BigDecimal codSala,String codTforma,
            Long capacidad) throws Exception {
        ISalaxtformaLogic salaxtformaLogic = new SalaxtformaLogic();
        salaxtformaLogic.updateSalaxtforma(codSala.toString(), codTforma.toString(), capacidad);
    }

    public static Salaxtforma getSalaxtforma(SalaxtformaId id)
        throws Exception {
        ISalaxtformaLogic salaxtformaLogic = new SalaxtformaLogic();
        Salaxtforma salaxtforma = null;

        try {
            salaxtforma = salaxtformaLogic.getSalaxtforma(id);
        } catch (Exception e) {
            throw e;
        }

        return salaxtforma;
    }

    public static List<Salaxtforma> findByCriteriaInSalaxtforma(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ISalaxtformaLogic salaxtformaLogic = new SalaxtformaLogic();

        return salaxtformaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Salaxtforma> findPageSalaxtforma(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ISalaxtformaLogic salaxtformaLogic = new SalaxtformaLogic();

        return salaxtformaLogic.findPageSalaxtforma(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberSalaxtforma() throws Exception {
        ISalaxtformaLogic salaxtformaLogic = new SalaxtformaLogic();

        return salaxtformaLogic.findTotalNumberSalaxtforma();
    }

    public static List<Secciones> getSecciones() throws Exception {
        ISeccionesLogic seccionesLogic = new SeccionesLogic();

        return seccionesLogic.getSecciones();
    }

    public static void saveSecciones(String codSecciones, String codDepat,
        BigDecimal codEntidad, BigDecimal codDepat_Departamentos) throws Exception {
        ISeccionesLogic seccionesLogic = new SeccionesLogic();
        seccionesLogic.saveSecciones(codSecciones, codDepat, codEntidad.toString(),
            codDepat_Departamentos.toString());
    }

    public static void deleteSecciones(String codSecciones, String codDepat,
        String codEntidad) throws Exception {
        ISeccionesLogic seccionesLogic = new SeccionesLogic();
        seccionesLogic.deleteSecciones(codSecciones, codDepat, codEntidad);
    }

    public static void updateSecciones(String codSecciones, String codDepat,
        String codEntidad, String codDepat_Departamentos) throws Exception {
        ISeccionesLogic seccionesLogic = new SeccionesLogic();
        seccionesLogic.updateSecciones(codSecciones, codDepat, codEntidad.toString(),
            codDepat_Departamentos.toString());
    }

    public static Secciones getSecciones(SeccionesId id)
        throws Exception {
        ISeccionesLogic seccionesLogic = new SeccionesLogic();
        Secciones secciones = null;

        try {
            secciones = seccionesLogic.getSecciones(id);
        } catch (Exception e) {
            throw e;
        }

        return secciones;
    }

    public static List<Secciones> findByCriteriaInSecciones(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ISeccionesLogic seccionesLogic = new SeccionesLogic();

        return seccionesLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Secciones> findPageSecciones(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ISeccionesLogic seccionesLogic = new SeccionesLogic();

        return seccionesLogic.findPageSecciones(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberSecciones() throws Exception {
        ISeccionesLogic seccionesLogic = new SeccionesLogic();

        return seccionesLogic.findTotalNumberSecciones();
    }

    public static List<SerOfrecen> getSerOfrecen() throws Exception {
        ISerOfrecenLogic serOfrecenLogic = new SerOfrecenLogic();

        return serOfrecenLogic.getSerOfrecen();
    }

    public static void saveSerOfrecen(String codSerO, String serONombre)
        throws Exception {
        ISerOfrecenLogic serOfrecenLogic = new SerOfrecenLogic();
        serOfrecenLogic.saveSerOfrecen(codSerO, serONombre);
    }

    public static void deleteSerOfrecen(String codSerO)
        throws Exception {
        ISerOfrecenLogic serOfrecenLogic = new SerOfrecenLogic();
        serOfrecenLogic.deleteSerOfrecen(codSerO);
    }

    public static void updateSerOfrecen(String codSerO, String serONombre)
        throws Exception {
        ISerOfrecenLogic serOfrecenLogic = new SerOfrecenLogic();
        serOfrecenLogic.updateSerOfrecen(codSerO, serONombre);
    }

    public static SerOfrecen getSerOfrecen(String codSerO)
        throws Exception {
        ISerOfrecenLogic serOfrecenLogic = new SerOfrecenLogic();
        SerOfrecen serOfrecen = null;

        try {
            serOfrecen = serOfrecenLogic.getSerOfrecen(codSerO);
        } catch (Exception e) {
            throw e;
        }

        return serOfrecen;
    }

    public static List<SerOfrecen> findByCriteriaInSerOfrecen(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ISerOfrecenLogic serOfrecenLogic = new SerOfrecenLogic();

        return serOfrecenLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<SerOfrecen> findPageSerOfrecen(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ISerOfrecenLogic serOfrecenLogic = new SerOfrecenLogic();

        return serOfrecenLogic.findPageSerOfrecen(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberSerOfrecen() throws Exception {
        ISerOfrecenLogic serOfrecenLogic = new SerOfrecenLogic();

        return serOfrecenLogic.findTotalNumberSerOfrecen();
    }

    public static List<SolAlixfuncionarios> getSolAlixfuncionarios()
        throws Exception {
        ISolAlixfuncionariosLogic solAlixfuncionariosLogic = new SolAlixfuncionariosLogic();

        return solAlixfuncionariosLogic.getSolAlixfuncionarios();
    }

    public static void saveSolAlixfuncionarios(Long cantidad,
        String consecutivo, String duracion, Date fechaUso, String labor,
        String lugartrabajo, Long cedula_Funcionarios,
        String codResta_Restaurantes, String codSolicituda_SoltAlimentos,
        String codTtrabajo_TipoTrabajo) throws Exception {
        ISolAlixfuncionariosLogic solAlixfuncionariosLogic = new SolAlixfuncionariosLogic();
        solAlixfuncionariosLogic.saveSolAlixfuncionarios(cantidad, consecutivo,
            duracion, fechaUso, labor, lugartrabajo, cedula_Funcionarios,
            codResta_Restaurantes, codSolicituda_SoltAlimentos,
            codTtrabajo_TipoTrabajo);
    }

    public static void deleteSolAlixfuncionarios(String consecutivo)
        throws Exception {
        ISolAlixfuncionariosLogic solAlixfuncionariosLogic = new SolAlixfuncionariosLogic();
        solAlixfuncionariosLogic.deleteSolAlixfuncionarios(consecutivo);
    }

    public static void updateSolAlixfuncionarios(Long cantidad,
        String consecutivo, String duracion, Date fechaUso, String labor,
        String lugartrabajo, Long cedula_Funcionarios,
        String codResta_Restaurantes, String codSolicituda_SoltAlimentos,
        String codTtrabajo_TipoTrabajo) throws Exception {
        ISolAlixfuncionariosLogic solAlixfuncionariosLogic = new SolAlixfuncionariosLogic();
        solAlixfuncionariosLogic.updateSolAlixfuncionarios(cantidad,
            consecutivo, duracion, fechaUso, labor, lugartrabajo,
            cedula_Funcionarios, codResta_Restaurantes,
            codSolicituda_SoltAlimentos, codTtrabajo_TipoTrabajo);
    }

    public static SolAlixfuncionarios getSolAlixfuncionarios(String consecutivo)
        throws Exception {
        ISolAlixfuncionariosLogic solAlixfuncionariosLogic = new SolAlixfuncionariosLogic();
        SolAlixfuncionarios solAlixfuncionarios = null;

        try {
            solAlixfuncionarios = solAlixfuncionariosLogic.getSolAlixfuncionarios(consecutivo);
        } catch (Exception e) {
            throw e;
        }

        return solAlixfuncionarios;
    }

    public static List<SolAlixfuncionarios> findByCriteriaInSolAlixfuncionarios(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ISolAlixfuncionariosLogic solAlixfuncionariosLogic = new SolAlixfuncionariosLogic();

        return solAlixfuncionariosLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<SolAlixfuncionarios> findPageSolAlixfuncionarios(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ISolAlixfuncionariosLogic solAlixfuncionariosLogic = new SolAlixfuncionariosLogic();

        return solAlixfuncionariosLogic.findPageSolAlixfuncionarios(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberSolAlixfuncionarios()
        throws Exception {
        ISolAlixfuncionariosLogic solAlixfuncionariosLogic = new SolAlixfuncionariosLogic();

        return solAlixfuncionariosLogic.findTotalNumberSolAlixfuncionarios();
    }

    public static List<SolEventos> getSolEventos() throws Exception {
        ISolEventosLogic solEventosLogic = new SolEventosLogic();

        return solEventosLogic.getSolEventos();
    }

   /* public static void saveSolEventos(String codSolicitude, String observacion,
        String loggin_Usuarios) throws Exception {
        ISolEventosLogic solEventosLogic = new SolEventosLogic();
        solEventosLogic.saveSolEventos(codSolicitude, observacion,
            loggin_Usuarios);
    }*/
    
    public static void saveSolEventos(String codSolicitude, String Descripcion,
            String seEjecutado, Date seFecha, String seNombre,
            String seOrganizador, String loggin_Usuarios,Date FechaInicio,Date FechaFin) throws Exception {
            ISolEventosLogic solEventosLogic = new SolEventosLogic();
            solEventosLogic.saveSolEventos(codSolicitude, Descripcion, seEjecutado,
                seFecha, seNombre, seOrganizador, loggin_Usuarios,FechaInicio,FechaFin);
        }

    public static void deleteSolEventos(String codSolicitude)
        throws Exception {
        ISolEventosLogic solEventosLogic = new SolEventosLogic();
        solEventosLogic.deleteSolEventos(codSolicitude);
    }

    public static void updateSolEventos(BigDecimal codSolicitude, String Descripcion,
            String seEjecutado, Date seFecha, String seNombre,
            String seOrganizador, String loggin_Usuarios,Date FechaInicio,Date FechaFin) throws Exception {
        ISolEventosLogic solEventosLogic = new SolEventosLogic();
        solEventosLogic.updateSolEventos(codSolicitude.toString(), Descripcion, seEjecutado,
                seFecha, seNombre, seOrganizador, loggin_Usuarios,FechaInicio,FechaFin);
    }

    public static SolEventos getSolEventos(String codSolicitude)
        throws Exception {
        ISolEventosLogic solEventosLogic = new SolEventosLogic();
        SolEventos solEventos = null;

        try {
            solEventos = solEventosLogic.getSolEventos(codSolicitude);
        } catch (Exception e) {
            throw e;
        }

        return solEventos;
    }

    public static List<SolEventos> findByCriteriaInSolEventos(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ISolEventosLogic solEventosLogic = new SolEventosLogic();

        return solEventosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<SolEventos> findPageSolEventos(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ISolEventosLogic solEventosLogic = new SolEventosLogic();

        return solEventosLogic.findPageSolEventos(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberSolEventos() throws Exception {
        ISolEventosLogic solEventosLogic = new SolEventosLogic();

        return solEventosLogic.findTotalNumberSolEventos();
    }

    public static List<SoliAliAsisExternos> getSoliAliAsisExternos()
        throws Exception {
        ISoliAliAsisExternosLogic soliAliAsisExternosLogic = new SoliAliAsisExternosLogic();

        return soliAliAsisExternosLogic.getSoliAliAsisExternos();
    }

    public static void saveSoliAliAsisExternos(String codSolEx, String empresa,
        String exNombre, String exteCargo, String codReservas_Reservas)
        throws Exception {
        ISoliAliAsisExternosLogic soliAliAsisExternosLogic = new SoliAliAsisExternosLogic();
        soliAliAsisExternosLogic.saveSoliAliAsisExternos(codSolEx, empresa,
            exNombre, exteCargo, codReservas_Reservas);
    }

    public static void deleteSoliAliAsisExternos(String codSolEx)
        throws Exception {
        ISoliAliAsisExternosLogic soliAliAsisExternosLogic = new SoliAliAsisExternosLogic();
        soliAliAsisExternosLogic.deleteSoliAliAsisExternos(codSolEx);
    }

    public static void updateSoliAliAsisExternos(String codSolEx,
        String empresa, String exNombre, String exteCargo,
        String codReservas_Reservas) throws Exception {
        ISoliAliAsisExternosLogic soliAliAsisExternosLogic = new SoliAliAsisExternosLogic();
        soliAliAsisExternosLogic.updateSoliAliAsisExternos(codSolEx, empresa,
            exNombre, exteCargo, codReservas_Reservas);
    }

    public static SoliAliAsisExternos getSoliAliAsisExternos(String codSolEx)
        throws Exception {
        ISoliAliAsisExternosLogic soliAliAsisExternosLogic = new SoliAliAsisExternosLogic();
        SoliAliAsisExternos soliAliAsisExternos = null;

        try {
            soliAliAsisExternos = soliAliAsisExternosLogic.getSoliAliAsisExternos(codSolEx);
        } catch (Exception e) {
            throw e;
        }

        return soliAliAsisExternos;
    }

    public static List<SoliAliAsisExternos> findByCriteriaInSoliAliAsisExternos(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ISoliAliAsisExternosLogic soliAliAsisExternosLogic = new SoliAliAsisExternosLogic();

        return soliAliAsisExternosLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<SoliAliAsisExternos> findPageSoliAliAsisExternos(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ISoliAliAsisExternosLogic soliAliAsisExternosLogic = new SoliAliAsisExternosLogic();

        return soliAliAsisExternosLogic.findPageSoliAliAsisExternos(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberSoliAliAsisExternos()
        throws Exception {
        ISoliAliAsisExternosLogic soliAliAsisExternosLogic = new SoliAliAsisExternosLogic();

        return soliAliAsisExternosLogic.findTotalNumberSoliAliAsisExternos();
    }

    public static List<SolicitAlimAstExter> getSolicitAlimAstExter()
        throws Exception {
        ISolicitAlimAstExterLogic solicitAlimAstExterLogic = new SolicitAlimAstExterLogic();

        return solicitAlimAstExterLogic.getSolicitAlimAstExter();
    }

    public static void saveSolicitAlimAstExter(String cargo,
        String empresa, String exNombre, String codSolicitude_SolEventos)
        throws Exception {
        ISolicitAlimAstExterLogic solicitAlimAstExterLogic = new SolicitAlimAstExterLogic();
        solicitAlimAstExterLogic.saveSolicitAlimAstExter(cargo, 
            empresa, exNombre, codSolicitude_SolEventos);
    }

    public static void deleteSolicitAlimAstExter(String codSolExt)
        throws Exception {
        ISolicitAlimAstExterLogic solicitAlimAstExterLogic = new SolicitAlimAstExterLogic();
        solicitAlimAstExterLogic.deleteSolicitAlimAstExter(codSolExt);
    }

    public static void updateSolicitAlimAstExter(String cargo,
        String codSolExt, String empresa, String exNombre,
        String codSolicitude_SolEventos) throws Exception {
        ISolicitAlimAstExterLogic solicitAlimAstExterLogic = new SolicitAlimAstExterLogic();
        solicitAlimAstExterLogic.updateSolicitAlimAstExter(cargo, codSolExt,
            empresa, exNombre, codSolicitude_SolEventos);
    }

    public static SolicitAlimAstExter getSolicitAlimAstExter(String codSolExt)
        throws Exception {
        ISolicitAlimAstExterLogic solicitAlimAstExterLogic = new SolicitAlimAstExterLogic();
        SolicitAlimAstExter solicitAlimAstExter = null;

        try {
            solicitAlimAstExter = solicitAlimAstExterLogic.getSolicitAlimAstExter(codSolExt);
        } catch (Exception e) {
            throw e;
        }

        return solicitAlimAstExter;
    }

    public static List<SolicitAlimAstExter> findByCriteriaInSolicitAlimAstExter(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ISolicitAlimAstExterLogic solicitAlimAstExterLogic = new SolicitAlimAstExterLogic();

        return solicitAlimAstExterLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<SolicitAlimAstExter> findPageSolicitAlimAstExter(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ISolicitAlimAstExterLogic solicitAlimAstExterLogic = new SolicitAlimAstExterLogic();

        return solicitAlimAstExterLogic.findPageSolicitAlimAstExter(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberSolicitAlimAstExter()
        throws Exception {
        ISolicitAlimAstExterLogic solicitAlimAstExterLogic = new SolicitAlimAstExterLogic();

        return solicitAlimAstExterLogic.findTotalNumberSolicitAlimAstExter();
    }

    public static List<SoltAlimentos> getSoltAlimentos()
        throws Exception {
        ISoltAlimentosLogic soltAlimentosLogic = new SoltAlimentosLogic();

        return soltAlimentosLogic.getSoltAlimentos();
    }

    public static void saveSoltAlimentos(String codSolicituda,
        String lugartrabajo, Long solCantidadasistente, String solDescripcion,
        Long solValor, String solcAtendida, String codCc_CentroDeCostos,
        String codProvee_Proveedores, String codTtrabajo_TipoTrabajo,
        String codigotipsolict_Tiposolicitudes, String loggin_Usuarios)
        throws Exception {
        ISoltAlimentosLogic soltAlimentosLogic = new SoltAlimentosLogic();
        soltAlimentosLogic.saveSoltAlimentos(codSolicituda, lugartrabajo,
            solCantidadasistente, solDescripcion, solValor, solcAtendida,
            codCc_CentroDeCostos, codProvee_Proveedores,
            codTtrabajo_TipoTrabajo, codigotipsolict_Tiposolicitudes,
            loggin_Usuarios);
    }

    public static void deleteSoltAlimentos(String codSolicituda)
        throws Exception {
        ISoltAlimentosLogic soltAlimentosLogic = new SoltAlimentosLogic();
        soltAlimentosLogic.deleteSoltAlimentos(codSolicituda);
    }

    public static void updateSoltAlimentos(String codSolicituda,
        String lugartrabajo, Long solCantidadasistente, String solDescripcion,
        Long solValor, String solcAtendida, String codCc_CentroDeCostos,
        String codProvee_Proveedores, String codTtrabajo_TipoTrabajo,
        String codigotipsolict_Tiposolicitudes, String loggin_Usuarios)
        throws Exception {
        ISoltAlimentosLogic soltAlimentosLogic = new SoltAlimentosLogic();
        soltAlimentosLogic.updateSoltAlimentos(codSolicituda, lugartrabajo,
            solCantidadasistente, solDescripcion, solValor, solcAtendida,
            codCc_CentroDeCostos, codProvee_Proveedores,
            codTtrabajo_TipoTrabajo, codigotipsolict_Tiposolicitudes,
            loggin_Usuarios);
    }

    public static SoltAlimentos getSoltAlimentos(String codSolicituda)
        throws Exception {
        ISoltAlimentosLogic soltAlimentosLogic = new SoltAlimentosLogic();
        SoltAlimentos soltAlimentos = null;

        try {
            soltAlimentos = soltAlimentosLogic.getSoltAlimentos(codSolicituda);
        } catch (Exception e) {
            throw e;
        }

        return soltAlimentos;
    }

    public static List<SoltAlimentos> findByCriteriaInSoltAlimentos(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ISoltAlimentosLogic soltAlimentosLogic = new SoltAlimentosLogic();

        return soltAlimentosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<SoltAlimentos> findPageSoltAlimentos(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ISoltAlimentosLogic soltAlimentosLogic = new SoltAlimentosLogic();

        return soltAlimentosLogic.findPageSoltAlimentos(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberSoltAlimentos() throws Exception {
        ISoltAlimentosLogic soltAlimentosLogic = new SoltAlimentosLogic();

        return soltAlimentosLogic.findTotalNumberSoltAlimentos();
    }

    public static List<SubArea> getSubArea() throws Exception {
        ISubAreaLogic subAreaLogic = new SubAreaLogic();

        return subAreaLogic.getSubArea();
    }

    public static void saveSubArea(String codSubarea, BigDecimal codSecciones,
        BigDecimal codDepat, BigDecimal codEntidad, String subNombre
       ) throws Exception {
        ISubAreaLogic subAreaLogic = new SubAreaLogic();
        subAreaLogic.saveSubArea(codSubarea, codSecciones.toString(), codDepat.toString(),
            codEntidad.toString(), subNombre);
    }

    public static void deleteSubArea(String codSubarea, String codSecciones,
        String codDepat, String codEntidad) throws Exception {
        ISubAreaLogic subAreaLogic = new SubAreaLogic();
        subAreaLogic.deleteSubArea(codSubarea, codSecciones, codDepat,
            codEntidad);
    }

    public static void updateSubArea(String codSubarea, String codSecciones,
        String codDepat,String  codEntidad, String subNombre) throws Exception {
        ISubAreaLogic subAreaLogic = new SubAreaLogic();
        subAreaLogic.updateSubArea(codSubarea, codSecciones.toString(), codDepat.toString(),
            codEntidad.toString(), subNombre);
    }

    public static SubArea getSubArea(SubAreaId id) throws Exception {
        ISubAreaLogic subAreaLogic = new SubAreaLogic();
        SubArea subArea = null;

        try {
            subArea = subAreaLogic.getSubArea(id);
        } catch (Exception e) {
            throw e;
        }

        return subArea;
    }

    public static List<SubArea> findByCriteriaInSubArea(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        ISubAreaLogic subAreaLogic = new SubAreaLogic();

        return subAreaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<SubArea> findPageSubArea(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ISubAreaLogic subAreaLogic = new SubAreaLogic();

        return subAreaLogic.findPageSubArea(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberSubArea() throws Exception {
        ISubAreaLogic subAreaLogic = new SubAreaLogic();

        return subAreaLogic.findTotalNumberSubArea();
    }

    public static List<TAlimentos> getTAlimentos() throws Exception {
        ITAlimentosLogic tAlimentosLogic = new TAlimentosLogic();

        return tAlimentosLogic.getTAlimentos();
    }

    public static void saveTAlimentos(String codTalimento, String taDescripcion)
        throws Exception {
        ITAlimentosLogic tAlimentosLogic = new TAlimentosLogic();
        tAlimentosLogic.saveTAlimentos(codTalimento, taDescripcion);
    }

    public static void deleteTAlimentos(String codTalimento)
        throws Exception {
        ITAlimentosLogic tAlimentosLogic = new TAlimentosLogic();
        tAlimentosLogic.deleteTAlimentos(codTalimento);
    }

    public static void updateTAlimentos(String codTalimento,
        String taDescripcion) throws Exception {
        ITAlimentosLogic tAlimentosLogic = new TAlimentosLogic();
        tAlimentosLogic.updateTAlimentos(codTalimento, taDescripcion);
    }

    public static TAlimentos getTAlimentos(String codTalimento)
        throws Exception {
        ITAlimentosLogic tAlimentosLogic = new TAlimentosLogic();
        TAlimentos tAlimentos = null;

        try {
            tAlimentos = tAlimentosLogic.getTAlimentos(codTalimento);
        } catch (Exception e) {
            throw e;
        }

        return tAlimentos;
    }

    public static List<TAlimentos> findByCriteriaInTAlimentos(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITAlimentosLogic tAlimentosLogic = new TAlimentosLogic();

        return tAlimentosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TAlimentos> findPageTAlimentos(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ITAlimentosLogic tAlimentosLogic = new TAlimentosLogic();

        return tAlimentosLogic.findPageTAlimentos(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTAlimentos() throws Exception {
        ITAlimentosLogic tAlimentosLogic = new TAlimentosLogic();

        return tAlimentosLogic.findTotalNumberTAlimentos();
    }

    public static List<TarifaAlimentos> getTarifaAlimentos()
        throws Exception {
        ITarifaAlimentosLogic tarifaAlimentosLogic = new TarifaAlimentosLogic();

        return tarifaAlimentosLogic.getTarifaAlimentos();
    }

    public static void saveTarifaAlimentos(String codProvee,
        String codTalimento, String codCAlimento, Long valor)
        throws Exception {
        ITarifaAlimentosLogic tarifaAlimentosLogic = new TarifaAlimentosLogic();
        tarifaAlimentosLogic.saveTarifaAlimentos(codProvee, codTalimento,
            codCAlimento, valor);
    }

    public static void deleteTarifaAlimentos(String codProvee,
        String codTalimento, String codCAlimento, Long valor)
        throws Exception {
        ITarifaAlimentosLogic tarifaAlimentosLogic = new TarifaAlimentosLogic();
        tarifaAlimentosLogic.deleteTarifaAlimentos(codProvee, codTalimento,
            codCAlimento, valor);
    }

    public static void updateTarifaAlimentos(String codProvee,
        String codTalimento, String codCAlimento, Long valor,
        String codCAlimento_ClaseAlimento, String codProvee_Proveedores)
        throws Exception {
        ITarifaAlimentosLogic tarifaAlimentosLogic = new TarifaAlimentosLogic();
        tarifaAlimentosLogic.updateTarifaAlimentos(codProvee, codTalimento,
            codCAlimento, valor, codCAlimento_ClaseAlimento,
            codProvee_Proveedores);
    }

    public static TarifaAlimentos getTarifaAlimentos(TarifaAlimentosId id)
        throws Exception {
        ITarifaAlimentosLogic tarifaAlimentosLogic = new TarifaAlimentosLogic();
        TarifaAlimentos tarifaAlimentos = null;

        try {
            tarifaAlimentos = tarifaAlimentosLogic.getTarifaAlimentos(id);
        } catch (Exception e) {
            throw e;
        }

        return tarifaAlimentos;
    }

    public static List<TarifaAlimentos> findByCriteriaInTarifaAlimentos(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITarifaAlimentosLogic tarifaAlimentosLogic = new TarifaAlimentosLogic();

        return tarifaAlimentosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TarifaAlimentos> findPageTarifaAlimentos(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITarifaAlimentosLogic tarifaAlimentosLogic = new TarifaAlimentosLogic();

        return tarifaAlimentosLogic.findPageTarifaAlimentos(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTarifaAlimentos()
        throws Exception {
        ITarifaAlimentosLogic tarifaAlimentosLogic = new TarifaAlimentosLogic();

        return tarifaAlimentosLogic.findTotalNumberTarifaAlimentos();
    }

    public static List<TElementos> getTElementos() throws Exception {
        ITElementosLogic tElementosLogic = new TElementosLogic();

        return tElementosLogic.getTElementos();
    }

    public static void saveTElementos(String codElem, String elDescripcion,
        String estado, String marca,String modelo) throws Exception {
        ITElementosLogic tElementosLogic = new TElementosLogic();
        tElementosLogic.saveTElementos(codElem, elDescripcion, estado, marca,modelo);
    }

    public static void deleteTElementos(String codElem)
        throws Exception {
        ITElementosLogic tElementosLogic = new TElementosLogic();
        tElementosLogic.deleteTElementos(codElem);
    }

    public static void updateTElementos(String codElem, String elDescripcion,
        String estado, String marca,String modelo) throws Exception {
        ITElementosLogic tElementosLogic = new TElementosLogic();
        tElementosLogic.updateTElementos(codElem, elDescripcion, estado, marca,modelo);
    }

    public static TElementos getTElementos(String codElem)
        throws Exception {
        ITElementosLogic tElementosLogic = new TElementosLogic();
        TElementos tElementos = null;

        try {
            tElementos = tElementosLogic.getTElementos(codElem);
        } catch (Exception e) {
            throw e;
        }

        return tElementos;
    }

    public static List<TElementos> findByCriteriaInTElementos(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITElementosLogic tElementosLogic = new TElementosLogic();

        return tElementosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TElementos> findPageTElementos(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ITElementosLogic tElementosLogic = new TElementosLogic();

        return tElementosLogic.findPageTElementos(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTElementos() throws Exception {
        ITElementosLogic tElementosLogic = new TElementosLogic();

        return tElementosLogic.findTotalNumberTElementos();
    }

    public static List<TForSalas> getTForSalas() throws Exception {
        ITForSalasLogic tForSalasLogic = new TForSalasLogic();

        return tForSalasLogic.getTForSalas();
    }

    public static void saveTForSalas(String codTforma, String tfDescripcion,
        BigDecimal codImagen_ImagenFormas) throws Exception {
        ITForSalasLogic tForSalasLogic = new TForSalasLogic();
        tForSalasLogic.saveTForSalas(codTforma, tfDescripcion,
            codImagen_ImagenFormas.toString());
    }

    public static void deleteTForSalas(String codTforma)
        throws Exception {
        ITForSalasLogic tForSalasLogic = new TForSalasLogic();
        tForSalasLogic.deleteTForSalas(codTforma);
    }

    public static void updateTForSalas(String codTforma, String tfDescripcion,
        BigDecimal codImagen_ImagenFormas) throws Exception {
        ITForSalasLogic tForSalasLogic = new TForSalasLogic();
        tForSalasLogic.updateTForSalas(codTforma, tfDescripcion,
            codImagen_ImagenFormas.toString());
    }

    public static TForSalas getTForSalas(String codTforma)
        throws Exception {
        ITForSalasLogic tForSalasLogic = new TForSalasLogic();
        TForSalas tForSalas = null;

        try {
            tForSalas = tForSalasLogic.getTForSalas(codTforma);
        } catch (Exception e) {
            throw e;
        }

        return tForSalas;
    }

    public static List<TForSalas> findByCriteriaInTForSalas(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITForSalasLogic tForSalasLogic = new TForSalasLogic();

        return tForSalasLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TForSalas> findPageTForSalas(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ITForSalasLogic tForSalasLogic = new TForSalasLogic();

        return tForSalasLogic.findPageTForSalas(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberTForSalas() throws Exception {
        ITForSalasLogic tForSalasLogic = new TForSalasLogic();

        return tForSalasLogic.findTotalNumberTForSalas();
    }

    public static List<Tiposolicitudes> getTiposolicitudes()
        throws Exception {
        ITiposolicitudesLogic tiposolicitudesLogic = new TiposolicitudesLogic();

        return tiposolicitudesLogic.getTiposolicitudes();
    }

    public static void saveTiposolicitudes(String codigotipsolict, String nombre)
        throws Exception {
        ITiposolicitudesLogic tiposolicitudesLogic = new TiposolicitudesLogic();
        tiposolicitudesLogic.saveTiposolicitudes(codigotipsolict, nombre);
    }

    public static void deleteTiposolicitudes(String codigotipsolict)
        throws Exception {
        ITiposolicitudesLogic tiposolicitudesLogic = new TiposolicitudesLogic();
        tiposolicitudesLogic.deleteTiposolicitudes(codigotipsolict);
    }

    public static void updateTiposolicitudes(String codigotipsolict,
        String nombre) throws Exception {
        ITiposolicitudesLogic tiposolicitudesLogic = new TiposolicitudesLogic();
        tiposolicitudesLogic.updateTiposolicitudes(codigotipsolict, nombre);
    }

    public static Tiposolicitudes getTiposolicitudes(String codigotipsolict)
        throws Exception {
        ITiposolicitudesLogic tiposolicitudesLogic = new TiposolicitudesLogic();
        Tiposolicitudes tiposolicitudes = null;

        try {
            tiposolicitudes = tiposolicitudesLogic.getTiposolicitudes(codigotipsolict);
        } catch (Exception e) {
            throw e;
        }

        return tiposolicitudes;
    }

    public static List<Tiposolicitudes> findByCriteriaInTiposolicitudes(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITiposolicitudesLogic tiposolicitudesLogic = new TiposolicitudesLogic();

        return tiposolicitudesLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Tiposolicitudes> findPageTiposolicitudes(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITiposolicitudesLogic tiposolicitudesLogic = new TiposolicitudesLogic();

        return tiposolicitudesLogic.findPageTiposolicitudes(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTiposolicitudes()
        throws Exception {
        ITiposolicitudesLogic tiposolicitudesLogic = new TiposolicitudesLogic();

        return tiposolicitudesLogic.findTotalNumberTiposolicitudes();
    }

    public static List<TipoTrabajo> getTipoTrabajo() throws Exception {
        ITipoTrabajoLogic tipoTrabajoLogic = new TipoTrabajoLogic();

        return tipoTrabajoLogic.getTipoTrabajo();
    }

    public static void saveTipoTrabajo(String codTtrabajo, String ttNombre)
        throws Exception {
        ITipoTrabajoLogic tipoTrabajoLogic = new TipoTrabajoLogic();
        tipoTrabajoLogic.saveTipoTrabajo(codTtrabajo, ttNombre);
    }

    public static void deleteTipoTrabajo(String codTtrabajo)
        throws Exception {
        ITipoTrabajoLogic tipoTrabajoLogic = new TipoTrabajoLogic();
        tipoTrabajoLogic.deleteTipoTrabajo(codTtrabajo);
    }

    public static void updateTipoTrabajo(String codTtrabajo, String ttNombre)
        throws Exception {
        ITipoTrabajoLogic tipoTrabajoLogic = new TipoTrabajoLogic();
        tipoTrabajoLogic.updateTipoTrabajo(codTtrabajo, ttNombre);
    }

    public static TipoTrabajo getTipoTrabajo(String codTtrabajo)
        throws Exception {
        ITipoTrabajoLogic tipoTrabajoLogic = new TipoTrabajoLogic();
        TipoTrabajo tipoTrabajo = null;

        try {
            tipoTrabajo = tipoTrabajoLogic.getTipoTrabajo(codTtrabajo);
        } catch (Exception e) {
            throw e;
        }

        return tipoTrabajo;
    }

    public static List<TipoTrabajo> findByCriteriaInTipoTrabajo(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoTrabajoLogic tipoTrabajoLogic = new TipoTrabajoLogic();

        return tipoTrabajoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoTrabajo> findPageTipoTrabajo(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ITipoTrabajoLogic tipoTrabajoLogic = new TipoTrabajoLogic();

        return tipoTrabajoLogic.findPageTipoTrabajo(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoTrabajo() throws Exception {
        ITipoTrabajoLogic tipoTrabajoLogic = new TipoTrabajoLogic();

        return tipoTrabajoLogic.findTotalNumberTipoTrabajo();
    }

    public static List<TipoUsuarios> getTipoUsuarios()
        throws Exception {
        ITipoUsuariosLogic tipoUsuariosLogic = new TipoUsuariosLogic();

        return tipoUsuariosLogic.getTipoUsuarios();
    }

    public static void saveTipoUsuarios(String codTusuario, String funcion)
        throws Exception {
        ITipoUsuariosLogic tipoUsuariosLogic = new TipoUsuariosLogic();
        tipoUsuariosLogic.saveTipoUsuarios(codTusuario, funcion);
    }

    public static void deleteTipoUsuarios(String codTusuario)
        throws Exception {
        ITipoUsuariosLogic tipoUsuariosLogic = new TipoUsuariosLogic();
        tipoUsuariosLogic.deleteTipoUsuarios(codTusuario);
    }

    public static void updateTipoUsuarios(String codTusuario, String funcion)
        throws Exception {
        ITipoUsuariosLogic tipoUsuariosLogic = new TipoUsuariosLogic();
        tipoUsuariosLogic.updateTipoUsuarios(codTusuario, funcion);
    }

    public static TipoUsuarios getTipoUsuarios(String codTusuario)
        throws Exception {
        ITipoUsuariosLogic tipoUsuariosLogic = new TipoUsuariosLogic();
        TipoUsuarios tipoUsuarios = null;

        try {
            tipoUsuarios = tipoUsuariosLogic.getTipoUsuarios(codTusuario);
        } catch (Exception e) {
            throw e;
        }

        return tipoUsuarios;
    }

    public static List<TipoUsuarios> findByCriteriaInTipoUsuarios(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoUsuariosLogic tipoUsuariosLogic = new TipoUsuariosLogic();

        return tipoUsuariosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoUsuarios> findPageTipoUsuarios(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoUsuariosLogic tipoUsuariosLogic = new TipoUsuariosLogic();

        return tipoUsuariosLogic.findPageTipoUsuarios(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoUsuarios() throws Exception {
        ITipoUsuariosLogic tipoUsuariosLogic = new TipoUsuariosLogic();

        return tipoUsuariosLogic.findTotalNumberTipoUsuarios();
    }

    public static List<TProveedores> getTProveedores()
        throws Exception {
        ITProveedoresLogic tProveedoresLogic = new TProveedoresLogic();

        return tProveedoresLogic.getTProveedores();
    }

    public static void saveTProveedores(String codTprovee,
        String tproveeDescripcion) throws Exception {
        ITProveedoresLogic tProveedoresLogic = new TProveedoresLogic();
        tProveedoresLogic.saveTProveedores(codTprovee, tproveeDescripcion);
    }

    public static void deleteTProveedores(String codTprovee)
        throws Exception {
        ITProveedoresLogic tProveedoresLogic = new TProveedoresLogic();
        tProveedoresLogic.deleteTProveedores(codTprovee);
    }

    public static void updateTProveedores(String codTprovee,
        String tproveeDescripcion) throws Exception {
        ITProveedoresLogic tProveedoresLogic = new TProveedoresLogic();
        tProveedoresLogic.updateTProveedores(codTprovee, tproveeDescripcion);
    }

    public static TProveedores getTProveedores(String codTprovee)
        throws Exception {
        ITProveedoresLogic tProveedoresLogic = new TProveedoresLogic();
        TProveedores tProveedores = null;

        try {
            tProveedores = tProveedoresLogic.getTProveedores(codTprovee);
        } catch (Exception e) {
            throw e;
        }

        return tProveedores;
    }

    public static List<TProveedores> findByCriteriaInTProveedores(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITProveedoresLogic tProveedoresLogic = new TProveedoresLogic();

        return tProveedoresLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TProveedores> findPageTProveedores(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITProveedoresLogic tProveedoresLogic = new TProveedoresLogic();

        return tProveedoresLogic.findPageTProveedores(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTProveedores() throws Exception {
        ITProveedoresLogic tProveedoresLogic = new TProveedoresLogic();

        return tProveedoresLogic.findTotalNumberTProveedores();
    }

    public static List<Usuarios> getUsuarios() throws Exception {
        IUsuariosLogic usuariosLogic = new UsuariosLogic();

        return usuariosLogic.getUsuarios();
    }

    public static void saveUsuarios(String contrasena, String loggin,
        Long cedula_Funcionarios, BigDecimal TipoUsuarios)
        throws Exception {
        IUsuariosLogic usuariosLogic = new UsuariosLogic();
        usuariosLogic.saveUsuarios(contrasena, loggin, cedula_Funcionarios,
            TipoUsuarios.toString());
    }

    public static void deleteUsuarios(String loggin) throws Exception {
        IUsuariosLogic usuariosLogic = new UsuariosLogic();
        usuariosLogic.deleteUsuarios(loggin);
    }

    public static void updateUsuarios(String contrasena, String loggin,
        Long cedula_Funcionarios,BigDecimal codTusuario_TipoUsuarios)
        throws Exception {
        IUsuariosLogic usuariosLogic = new UsuariosLogic();
        usuariosLogic.updateUsuarios(contrasena, loggin, cedula_Funcionarios,
            codTusuario_TipoUsuarios.toString());
    }

    public static Usuarios getUsuarios(String loggin) throws Exception {
        IUsuariosLogic usuariosLogic = new UsuariosLogic();
        Usuarios usuarios = null;

        try {
            usuarios = usuariosLogic.getUsuarios(loggin);
        } catch (Exception e) {
            throw e;
        }

        return usuarios;
    }

    public static List<Usuarios> findByCriteriaInUsuarios(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IUsuariosLogic usuariosLogic = new UsuariosLogic();

        return usuariosLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Usuarios> findPageUsuarios(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IUsuariosLogic usuariosLogic = new UsuariosLogic();

        return usuariosLogic.findPageUsuarios(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberUsuarios() throws Exception {
        IUsuariosLogic usuariosLogic = new UsuariosLogic();

        return usuariosLogic.findTotalNumberUsuarios();
    }
}
